const fs = require("fs");
const path = require("path");
const { ImagePool } = require("@squoosh/lib");

// 初始化 Squoosh 图像池，限制并发线程数为 4
const imagePool = new ImagePool(4);

// 累计总的原始大小和压缩后大小
let totalOriginalSize = 0;
let totalCompressedSize = 0;

// 批量处理图片
async function processImage(inputPath, outputPath, type) {
  const image = imagePool.ingestImage(fs.readFileSync(inputPath));

  try {
    const encodedImage = await image.encode({
      webp: {
        lossless: false, // 启用无损压缩
        nearLossless: true, // 启用接近无损压缩
        effort: 6, // 设置压缩努力程度，值为 1-10
        quality: 85, // 设置压缩质量
      },
      mozjpeg: {
        quality: 80, // 设置压缩后的 JPEG 图片质量（0-100，数字越低，图片越小，质量越差）
      },
    });

    // 获取 binary 数据并确保是 Uint8Array
    if (
      !encodedImage[type] ||
      !(encodedImage[type].binary instanceof Uint8Array)
    ) {
      console.log(
        "=============================Failed to encode the image or webp binary is not Uint8Array."
      );
      return;
    }

    // 确保输出目录存在
    const outputDir = path.dirname(outputPath);
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true }); // 创建目录
    }

    // 使用 binary 数据创建 Buffer 并写入文件
    fs.writeFileSync(outputPath, Buffer.from(encodedImage[type].binary));

    // 获取文件的原始大小和压缩后的大小
    const originalSize = fs.statSync(inputPath).size; // 原始文件大小
    const compressedSize = Buffer.from(encodedImage[type].binary).length; // 压缩后文件大小

    // 累计总的原始大小和压缩后大小
    totalOriginalSize += originalSize;
    totalCompressedSize += compressedSize;

    // 打印每张图片的压缩信息
    console.log(`图片名 ${path.basename(inputPath)}:`);
    console.log(`原大小: ${(originalSize / 1024).toFixed(2)} KB`);
    console.log(`压缩后大小: ${(compressedSize / 1024).toFixed(2)} KB`);
    console.log(
      `压缩率: ${(
        ((originalSize - compressedSize) / originalSize) *
        100
      ).toFixed(2)}%`
    );
    console.log("------------------------");
  } catch (error) {
    console.error("Error during encoding:", error);
  }
}

// 主程序：批量处理文件夹中的图片
async function processImages(img, newimg, type) {
  const inputDir = path.resolve(__dirname, "images"); // 输入文件夹
  const outputDir = path.resolve(__dirname, "newimages"); // 输出文件夹

  // 确保输出文件夹存在
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir); // 如果输出文件夹不存在，创建它
  }

  const files = fs.readdirSync(inputDir).filter((file) => file.endsWith(img)); // 获取所有PNG、jpeg文件

  if (files.length === 0) {
    return;
  }

  for (const file of files) {
    const inputPath = path.join(inputDir, file);
    const outputPath = path.join(outputDir, file.replace(img, newimg));

    await processImage(inputPath, outputPath, type); // 处理每个图片
  }

  await imagePool.close(); // 处理完毕后，关闭图像池

  // 打印所有图片压缩的总百分比
  const totalReduction = (
    ((totalOriginalSize - totalCompressedSize) / totalOriginalSize) *
    100
  ).toFixed(2);
  console.log("=====================================");
  console.log(`总大小: ${(totalOriginalSize / 1024 / 1024).toFixed(2)} MB`);
  console.log(`压缩后: ${(totalCompressedSize / 1024 / 1024).toFixed(2)} MB`);
  console.log(`压缩率: ${totalReduction}%`);
}
/**
 * [catch description]
 *
 * @param   {[img]}  .png   [.png .jepg] 需要转换的图片
 * @param   {[newimg]}  .webp  [.webp .jepg] 转换成某类型
 * @param   {[type]}  .webp  [.webp .mozjpeg] 设置
 */
processImages(".png", ".jepg", "mozjpeg").catch((err) =>
  console.error("Error processing images:", err)
);
